import {
  Component, EventEmitter, Input, OnInit, Output, ViewEncapsulation, ChangeDetectorRef,
  OnDestroy
} from '@angular/core';
import {ActivatedRoute} from '@angular/router';
import {MatchService} from "app/pages/match/match.service";
import {Subject} from "rxjs/Subject";
import {Subscription} from "rxjs/Subscription";

@Component({
  selector: 'match-schedule',
  templateUrl: './match-schedule.component.html',
  styleUrls: ['./match-schedule.component.scss'],
  encapsulation: ViewEncapsulation.None
})
export class MatchScheduleComponent implements OnInit, OnDestroy {
  @Input() matchId: number;
  @Output() scrollComplete: EventEmitter<any> = new EventEmitter<any>();
  @Output() disabledScroll: EventEmitter<any> = new EventEmitter<any>();

  public matchs = []; // 赛程（淘汰赛、积分赛）
  public cupMatchs = []; // 赛程（杯赛）
  public matchsCache = []; // 赛程缓存
  public allPageMatchs = []; // 全部页赛程(杯赛)
  public params = {
    matchId: 0,
    rows: 10,
    page: 1
  };
  public dataStore = {
    scheduleType: 0, // 赛程类型
    groupNameArr: [], // 分组（杯赛）
    currentGroupName: '', // 当前分组（杯赛）
    currentGradeIndex: 0, // 当前轮次索引（杯赛）
    finalsGradeMarkArr: [], // 决赛轮次标记（淘汰赛）
    totalGradeCount: 0, // 总轮次（淘汰赛）
  };
  public stateStore = {
    haveData: true,
    showGroupFilter: false,
    openGroupFilter: false,
    showGradeFilter: false
  };
  public subscription: Subscription = new Subscription();
  public ngUnsubscribe: Subject<any> = new Subject<any>();
  public pageDate = {
    isCup: false // 是否杯赛
  };

  constructor(public route: ActivatedRoute,
              public service: MatchService) {
  }

  /**
   * 获取赛事详情赛程列表（淘汰赛、积分赛）
   * @param matchId 赛事ID
   */
  getCompetitionSchedule() {
    this.service.getCompetitionSchedule(this.params).takeUntil(this.ngUnsubscribe).subscribe(res => {
      const matchs = res.data.scheduleList.list;
      if (res.result === '0' && matchs.length > 0) {
        this.params['page']++;
        this.scrollComplete.emit(); // 请求完成

        this.dataStore.totalGradeCount = res.data.maxGrade; // 缓存总轮次
        this.matchsCache = this.matchsCache.concat(matchs); // 合并数组
        this.handleGrade();

        if (!res.data.scheduleList.hasNextPage) {
          this.disabledScroll.emit(true); // 没有更多数据
          this.dataStore.finalsGradeMarkArr = res.data.grades.split(',').slice(-3); // 淘汰赛最后三轮  4/1决赛  半决赛  决赛
        }
      } else { // 请求出错
        this.stateStore.haveData = false;
        this.disabledScroll.emit(false);
      }
    });
  }

  /**
   * @description 处理轮次（淘汰赛、积分赛）
   * @author ouyqx-691
   * date 2017/10/13
   */
  handleGrade() {
    this.matchs = []; //  每次上滑加载后清空数组以免轮次错乱
    let stage = 1;
    const matchs = this.matchsCache; // 每次上滑加载后全部重新处理一次
    const normalMatchsArr = []; // 存储全部已确定的赛程
    const totalGradeCount = this.dataStore.totalGradeCount; // 总轮次
    for (let i = 0; i < matchs.length; i++) {
      const match = matchs[i];
      if (match.grade === stage) {
        // 处理决赛轮次
        if (this.dataStore.scheduleType === 24005) { // 淘汰赛
          switch (stage) {
            case totalGradeCount:
              match.finals = '决赛';
              this.handleChampionMark(match);
              break;
            case totalGradeCount - 1:
              match.finals = '半决赛';
              break;
            case totalGradeCount - 2:
              match.finals = '四分之一决赛';
              break;
            default:
              match.stage = match.grade;  // 处理普通轮次
          }
        } else { // 积分赛
          match.stage = match.grade;  // 处理普通轮次
        }
        stage++; // 处理完一轮，轮次递增，避免重复处理
      }
      // 过滤掉未确定的比赛
      if (match.hostUserId && match.guestUserId && match.hostSeedValue && match.guestSeedValue) {
        normalMatchsArr.push(match);
      }
    }
    this.matchs = normalMatchsArr;
  }

  /**
   * @description 处理冠军标记（淘汰赛、杯赛）
   * @author ouyqx-691
   * date 2017/10/13
   */
  handleChampionMark(match) {
    const homeScore = Number.parseInt(match['homeScore']);
    const guestScore = Number.parseInt(match['guestScore']);
    if (homeScore || guestScore) { // 比分已产生
      if (homeScore > guestScore) {
        match['winer'] = 'host';
      } else {
        match['winer'] = 'guest';
      }
    }
  }

  /**
   * @description 获取杯赛赛程（杯赛）
   * @author ouyqx-691
   * date 2017/10/11
   */
  getCupCompetitionSchedule() {
    const params = {
      matchId: this.matchId
    };
    this.service.getCupCompetitionSchedule(params).subscribe(res => {

      if (res.result === '0' && res.data) {
        const groupName = res.data.groupName;
        // 没有数据
        if (!res.data.groupName) {
          return;
        }
        this.stateStore.showGroupFilter = true; // 显示分组筛选
        this.dataStore.groupNameArr = groupName;
        this.dataStore.groupNameArr = res.data.groupName;
        this.matchsCache = res.data.cupGradeDataMap;
        this.sortCupScheduleByGroup(res.data.groupName[0]); // 首次查出A组数据
        this.disabledScroll.emit(true); // 没有更多数据
      } else { // 请求出错
        this.stateStore.haveData = false;
        this.disabledScroll.emit(false);
      }
    });
  }


  /**
   * @description 选择分组（杯赛）
   * @author ouyqx-691
   * date 2017/10/11
   */
  selectGroup(e) {
    const tag = e.target.tagName;
    if (tag === 'P') {
      this.stateStore.openGroupFilter = !this.stateStore.openGroupFilter;
    } else {
      const groupName = e.target.innerText.replace(/(^\s*)|(\s*$)/g, ""); // 获取所点击的组名并去除空格
      this.stateStore.openGroupFilter = false; // 隐藏组别筛选
      this.sortCupScheduleByGroup(groupName);
    }
  }

  /**
   * @description 通过分组显示赛程（杯赛）
   * @author ouyqx-691
   * date 2017/10/11
   */
  sortCupScheduleByGroup(groupName: string) {
    this.dataStore.currentGroupName = groupName; // 存储当前分组组名
    this.cupMatchs = this.matchsCache[groupName]; // 单组杯赛赛程信息
    this.sortCupScheduleByGrade(0); // 首次查出第一轮数据

    if (this.dataStore.currentGroupName.indexOf('组') < 0) { // 分组为1/4半决赛、半决赛、决赛的组别时隐藏轮次筛选
      this.stateStore.showGradeFilter = false;
      if (this.dataStore.currentGroupName.indexOf('决赛') === 0) { // 处理冠军
        const finals = this.matchs[0];
        this.handleChampionMark(finals);
      }
    } else {
      this.stateStore.showGradeFilter = true;
    }
  }

  /**
   * @description 通过轮次显示赛程（杯赛）
   * @author ouyqx-691
   * date 2017/10/11
   */
  sortCupScheduleByGrade(grade: 0) {
    this.params.page = 1; // 重置为第一页
    const allGradeMatchs = this.cupMatchs[grade]; // 所有轮次赛程列表
    this.dataStore.currentGradeIndex = grade;
    this.matchs = allGradeMatchs.matchScheduleResps; // 单轮杯赛赛程列表
  }

  ngOnInit() {
    this.params.matchId = this.matchId;
    this.dataStore.scheduleType = this.service.competitionStore.scheduleType;
    this.service.competitionStore.cupCodeArr.filter((value) => {
      if (this.dataStore.scheduleType === value) {
        this.pageDate.isCup = true;
      }
    });
  }

  ngOnDestroy() {
    this.subscription.unsubscribe();
  }
}
